package org.example.producer;

import com.alibaba.fastjson.JSONObject;
import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;
import org.example.MyKafkaProducer;
import org.example.config.LocalPartition;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.Properties;

/**
 * Kafka producer
 * 发送Kafka消息
 * @author youshang
 * @date 2020/12/28 15:46
 **/
public class LocalKafkaProducer implements MyKafkaProducer {

    @Override
    public void send(String topic, Object key, Object value) {
        Producer<String, String> producer = null;
        Properties properties = new Properties();
//        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.169.3.123:9092,192.169.3.124:9092,192.169.3.125:9092");
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka-123:9092,kafka-124:9092,kafka-125:9092");
//        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, kafkaConfiguration.getKafkaBootstrapServers());
        //不指定事务ID使用事务会报错
//        properties.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, "transactionalId");
        //一批数据
//        properties.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384); //上网搜
//        properties.put(ProducerConfig.LINGER_MS_CONFIG, 1);  //batch.size 和 linger.ms 联合使用
//        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432);

        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        //马老师解释：
        // 0  吞吐量最高，只管发送给leader不管回应，有可能会出现消息丢失(发送给leader然后leader宕机了。。。)
        // 1 leader收到消息之后会回应，还是会发生消息丢失  producer -> leader -> 副本 (不会到副本)
        // all isr follow的partition都收到消息(leader本质也是isr)，最大限度的避免消息丢失,
        //补充
        // 0 producer发送消息不进行任何后续确认，此时认为消息确认发送成功 producer ->
        // 1 producer发送消息到kafka leader的ACK确认消息，此时认为消息确认发送成功 producer -> kafka leader
        //all producer发送消息到Kafka leader的ACK确认消息，follower拉取kafka leader消息 follower确认消息，此时认为消息确认发送成功 producer -> kafka leader -> kafka follower
        //博客解释：
        //0：表示不进行消息接收是否成功的确认；不能保证消息是否发送成功，生成环境基本不会用。
        //1：默认值，表示当 Leader 接收成功时确认；只要 Leader 存活就可以保证不丢失，保证了吞吐量。所以默认的 producer 级别是 at least once。
        //all：保证 leader 和 follower 不丢，但是如果网络拥塞，没有收到 ACK，会有重复发的问题。
        properties.put(ProducerConfig.ACKS_CONFIG, "all");
        //重试三次
        properties.put(ProducerConfig.RETRIES_CONFIG, 3);

        //* 强一致性，设置会导致吞吐量变低 ，强制使一个分区中的消息是有序的
        properties.put(ProducerConfig.MAX_IN_FLIGHT_REQUESTS_PER_CONNECTION, 1);
        //* 指定分区排序规则，当存在多个分区的时候为了保证发送的消息是有序的，自定义排序规则，如果单独是一个分区的情况下可以无视
        // 在极端的情况下还是会出现乱序的情况
        properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG, LocalPartition.class);
        //自动生产ID用于区分消息，为了避免重复发送，现在就是幂等
        properties.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG, "true");

        try {
            producer = new KafkaProducer<>(properties);
            String jsonString = JSONObject.toJSONString(value);
            ProducerRecord record = new ProducerRecord(topic, key, jsonString);
            //1.异步发送
            producer.send(record);
//            for (int i = 0; i < 100; i++) {
//                String key = "message" + i;
//                String msg = "This is Message " + i;
//                ProducerRecord<String, String> record = new ProducerRecord<>(topic, key, msg);
//                //1.异步发送
//                producer.send(record);
            //2.同步发送
//                Future<RecordMetadata> send = producer.send(record);
//                RecordMetadata recordMetadata = send.get();
//                int partition = recordMetadata.partition();//获得当前数据是发送到哪个分区
//                System.out.println(String.format("key -> %s,partition -> %s", key, partition + ""));
            //3.异步带回调
//                Future<RecordMetadata> send = producer.send(record, new Callback() {
//                    @Override
//                    public void onCompletion(RecordMetadata metadata, Exception exception) {
//                        if (exception != null) {
//                            exception.printStackTrace();
//                        } else {
//                            int partition = metadata.partition();//查看当前数据发送到哪个分区
//                            System.out.println(String.format("key -> %s,partition -> %s", key, partition));
//                        }
//                    }
//                });
//            }
            //使用kafka事务
//            producer.initTransactions();
//            producer.beginTransaction();
            //发送事务消息
//            ProducerRecord<String, String> helloWorld = new ProducerRecord<>("test","message1", "第一条消息！！！！");
//            producer.send(helloWorld);
            //提交事务
//            producer.commitTransaction();
        } catch (Exception e) {
            //中止事务
//            producer.abortTransaction();
            e.printStackTrace();
        }finally {
            producer.close();
        }
    }
}
